/**
 * 处理流式消息更新的自定义Hook
 */
import { useState, useCallback, useRef } from 'react';
import { Message } from '../../../types/chat';

/**
 * 自定义Hook: 处理AI消息流式响应
 */
export const useStreamingMessage = (
    setMessages: React.Dispatch<React.SetStateAction<Message[]>>
) => {
    // 是否正在接收流式响应
    const [isStreaming, setIsStreaming] = useState(false);
    // 当前接收到的流式消息ID
    const [streamingMessageId, setStreamingMessageId] = useState<string | null>(null);

    // 使用ref来在异步回调中获取最新状态
    const streamingContentRef = useRef<string>('');
    // 跟踪已接收的消息块，防止重复
    const receivedChunksRef = useRef<Set<string>>(new Set());
    // 跟踪最后处理的消息ID
    const lastMessageIdRef = useRef<string | null>(null);

    /**
     * 处理流式消息块
     * @param chunk 新接收的消息块
     * @param messageId 消息ID
     * @param isFirstChunk 是否是第一个消息块
     * @param isLastChunk 是否是最后一个消息块
     */
    const handleStreamChunk = useCallback((
        chunk: string,
        messageId: string,
        isFirstChunk: boolean = false,
        isLastChunk: boolean = false
    ) => {
        // 如果是新的消息ID，重置当前流式消息的状态，但不影响历史消息
        if (messageId !== lastMessageIdRef.current) {
            console.log('[流式响应] 新消息ID，重置当前流式状态:', { oldId: lastMessageIdRef.current, newId: messageId });
            lastMessageIdRef.current = messageId;
            isFirstChunk = true; // 强制作为首个块处理
            streamingContentRef.current = '';
            receivedChunksRef.current.clear();
        }

        // 首次输出块，初始化流式状态
        if (isFirstChunk) {
            console.log('[流式响应] 初始化:', { messageId });
            setIsStreaming(true);
            setStreamingMessageId(messageId);
            streamingContentRef.current = '';
            receivedChunksRef.current.clear();

            // 确保立即更新消息列表中的流式消息
            setMessages(prev => {
                // 确保只更新AI消息，不修改用户消息
                const foundAiMessage = prev.find(msg => msg.id === messageId && !msg.isUser);
                if (!foundAiMessage) {
                    console.warn('[流式响应] 未找到对应AI消息:', messageId);
                    return prev; // 如果找不到对应的AI消息，直接返回原状态
                }

                return prev.map(msg =>
                    msg.id === messageId && !msg.isUser
                        ? { ...msg, text: '', isTypingIndicator: true }
                        : msg
                );
            });
        }

        // 仅在有内容时更新，并且确保不重复处理相同的块
        if (chunk && chunk.length > 0) {
            // 使用内容前10个字符作为检查重复的简单标识
            const chunkId = `${messageId}-${chunk.substring(0, Math.min(10, chunk.length))}`;

            // 如果已经处理过这个块，跳过
            if (receivedChunksRef.current.has(chunkId)) {
                console.log('[流式响应] 跳过重复块:', { messageId, chunkPreview: chunk.substring(0, 10) });
                return;
            }

            // 标记为已处理
            receivedChunksRef.current.add(chunkId);

            console.log('[流式响应] 接收新内容:', {
                messageId,
                chunkLength: chunk.length,
                chunkPreview: chunk.substring(0, 10),
                currentLength: streamingContentRef.current.length
            });

            // 更新当前流式内容
            streamingContentRef.current += chunk; // 只添加新的chunk

            // 立即更新消息列表中的流式消息，但只更新当前消息ID对应的内容
            setMessages(prev => {
                // 先检查该消息ID是否是一个AI消息，防止更新用户消息
                const foundAiMessage = prev.find(msg => msg.id === messageId && !msg.isUser);
                if (!foundAiMessage) {
                    console.warn('[流式响应] 未找到对应AI消息:', messageId);
                    return prev; // 如果找不到对应的AI消息，直接返回原状态
                }

                return prev.map(msg =>
                    msg.id === messageId && !msg.isUser // 确保仅更新当前流式消息
                        ? { ...msg, text: streamingContentRef.current, isTypingIndicator: true }
                        : msg
                );
            });
        }

        // 最后一次输出块，清理流式状态
        if (isLastChunk) {
            console.log('[流式响应] 结束:', {
                messageId,
                finalLength: streamingContentRef.current.length,
                finalPreview: streamingContentRef.current.substring(0, 20) + '...'
            });
            setIsStreaming(false);
            setStreamingMessageId(null);
            receivedChunksRef.current.clear();

            // 确保最终消息状态更新，但只更新当前消息ID对应的内容
            setMessages(prev => {
                // 确保只更新AI消息，不修改用户消息
                const foundAiMessage = prev.find(msg => msg.id === messageId && !msg.isUser);
                if (!foundAiMessage) {
                    console.warn('[流式响应] 未找到对应AI消息:', messageId);
                    return prev; // 如果找不到对应的AI消息，直接返回原状态
                }

                return prev.map(msg =>
                    msg.id === messageId && !msg.isUser // 确保仅更新当前流式消息
                        ? { ...msg, text: streamingContentRef.current, isTypingIndicator: false, isNew: false }
                        : msg
                );
            });
        }
    }, [setMessages]);

    // 创建ref版本的handleStreamChunk，用于异步闭包中避免过期引用问题
    const handleStreamChunkRef = useRef(handleStreamChunk);
    handleStreamChunkRef.current = handleStreamChunk;

    return {
        isStreaming,
        streamingMessageId,
        handleStreamChunk,
        handleStreamChunkRef
    };
}; 